第3章面向对象 - 内部类 - 《Java基础入门笔记》

内部类
- 内部类的位置
- 匿名内部类

内部类

定义：将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。

访问特点：内部类可以直接访问外部类中的成员，包括私有成员。而外部类要访问内部类中的成员必须要建立内部类的对象。

示例1：

 /*
 内部类的设计：
 分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义
内部类。
 */
 class Outer{
        private int num = 3;
        class Inner //内部类
        {
              void show(){
                   System.out.println("show run..." + num);
              }
        }
        public void method(){
             Inner in = new Inner();
             in.show();
        }
 }
 class InnerClassDemo{
        public static void main(String[] args){
             Outer out = new Outer();
             out.method();
        }
 }

运行结果：

示例2：

class Outer{
    private int num = 3;
    class Inner
    {
        void show(){
            System.out.println("show run..." + num);
        }
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        //直接访问外部类中的内部类中的成员
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }
}

运行结果：

内部类的位置

内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中
的静态成员。

示例1：

class Outer{
    private static int num = 3;
    static class Inner
    {
        void show(){
            System.out.println("show run..." + num);
        }
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        //如果内部类是静态的，相当于一个外部类
        Outer.Inner in = new Outer.Inner();
        in.show();
    }
}

运行结果：

示例2：如果内部类是静态的，内部类成员也是静态的，可以不用创建内部类对象，直接调用。

class Outer{
    private static int num = 3;
    static class Inner
    {
        static void show(){
            System.out.println("show run..." + num);
        }
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        Outer.Inner.show();
    }
}

运行结果：

PS：如果内部类中定义了静态成员，该内部类也必须是静态的！

示例：

class Outer{
    private static int num = 3;
    static class Inner
    {
        static void show(){
            System.out.println("show run..." + num);
        }
    }
}

2、为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。

示例：

class Outer{
    int num = 3;
    class Inner{
        int num = 4;
        void show(){
            int num = 5;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }
    void method(){
        new Inner().show();
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        new Outer().method();
    }
}

运行结果：

3、内部类定义在局部位置上，也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。

示例：

class Outer{
    int num = 3;
    void method(final int y){
        final int x = 9;
        class Inner{
            void show(){
                System.out.println("show..." + x + "," + y);
            }
        }
        Inner in = new Inner();
        in.show();
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        new Outer().method(4);
    }
}

运行结果：

匿名内部类

定义：就是内部类的简化写法。
前提：内部类可以继承或实现一个外部类或者接口。
格式：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

什么时候使用匿名内部类呢？
通常使用方法是接口类型参数，并且该接口中的方法不超过三个，可以将匿名内部类作为参数传递。

好处：增强阅读性。

示例1：

abstract class Demo{
    abstract void show();
}
class Outer{
    int num = 4;
    void method(){
        new Demo(){//匿名内部类
            void show(){
                System.out.println("show......" + num);
            }
        }.show();
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        new Outer().method();
    }
}

运行结果：

示例2：

interface Inter{
    void show1();
    void show2();
}
class Outer{
    public void method(){
        Inter in = new Inter(){
            public void show1(){
                System.out.println("...show1...." );
            }
            public void show2(){
                System.out.println("...show2...." );
            }
        };
        in.show1();
        in.show2();
    }
}
class InnerClassDemo{
    public static void main(String[] args){
        new Outer().method();
    }
}

运行结果：

示例3：

interface Inter{
    void show1();
    void show2();
}
/*
通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递。
*/
class InnerClassDemo{
    public static void main(String[] args){
        show(new Inter(){
            public void show1(){
                System.out.println("...show1..." );
            }
            public void show2(){
                System.out.println("...show2..." );
            }
        });
    }
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}

运行结果：

对象的初始化过程

示例：

class Fu{
    int num = 9;
    {
        System.out.println("Fu" );
    }
    Fu(){
        super();//Object
        //显示初始化
        //构造代码块初始化
        show();
    }
    void show(){
        System.out.println("fu show " + num);//被覆盖，运行子类的
    }
}
class Zi extends Fu{
    int num = 8;
    {
        System.out.println("Zi" );
    }
    Zi(){
        super();
        //显示初始化
        //构造代码块初始化
        show();
    }
    void show(){
        System.out.println("zi show " + num);
    }
}
public class Demo{
    public static void main(String[] args){
        new Zi();
    }
}

运行结果